Modular asl component

ABSTRACT

A system for source language module interaction using an event mechanism includes one or more subsystems to detect a producer event, detect a consumer event, generate a new source language method for the producer event and a new source language method for the consumer event, and link the producer event and the consumer event using the new source language method. In an embodiment, the source language may be ASL.

BACKGROUND

The present disclosure relates generally to information handling systems (IHS), and more particularly to a modular advanced configuration and power interface (ACPI) source language (ASL) for an IHS.

As the value and use of information continues to increase, individuals and businesses seek additional ways to process and store information. One option is an information handling system (IHS). An IHS generally processes, compiles, stores, and/or communicates information or data for business, personal, or other purposes. Because technology and information handling needs and requirements may vary between different applications, IHSs may also vary regarding what information is handled, how the information is handled, how much information is processed, stored, or communicated, and how quickly and efficiently the information may be processed, stored, or communicated. The variations in IHSs allow for IHSs to be general or configured for a specific user or specific use such as financial transaction processing, airline reservations, enterprise data storage, or global communications. In addition, IHSs may include a variety of hardware and software components that may be configured to process, store, and communicate information and may include one or more computer systems, data storage systems, and networking systems.

IHS design is moving from basic input/output (BIOS) architecture to extensible firmware interface (EFI) architecture which is modular in nature. The EFI is generally known as a specification/system that defines a software interface between an operating system and platform firmware. A form of EFI is also known as unified EFI (UEFI). BIOS modules/drivers generally interact with other drivers in terms of protocol & event. Drivers register for a specific event and other drivers broadcast the event that causes those pending event methods to be invoked. An event is generally known by those having skill in the art as an action in an IHS that may be initiated by the user, a device (e.g., a timer, a keyboard, and a variety of other devices) or by the operating system. In event driven programming, the flow of the program is generally determined by the events, such as user actions or messages from other programs.

A problem arises with this architecture for advanced configuration and power interface (ACPI) components. ACPI components commonly use ACPI source language (ASL). However, ASL traditionally does not support such a modular concept. The BIOS ACPI components are generally written in a very primitive ASL language that does not follow advanced programming methods, such as callbacks, methods registration and indirect method invocation. Thus, the ASL language poses many challenges to BIOS programmers. For example, one ACPI method may need to call other ACPI methods by the same name. ASL does not have a concept of broadcasting an event to other ASL method. Currently the ASL event method explicitly calls out each of the interested methods that need to act on such event. It is very difficult to integrate ASL modules from various product vendors because one module needs to know the scope, names and parameter of the other dependent modules. This causes a challenge for BIOS writers to isolate the ASL modules as each ASL module directly calls out functions in other ASL component. Also when writing an ASL code that interacts with various platform behavior, chipset, feature etc. the code becomes very convoluted and the code developer adds a build time conditional statement (for example. #if<>/#else statement) in the files so that ASL code behavior can change based on platform, feature, chipset and etc.

When writing ASL code there is a need to build the modular concept (similar to UEFI) so that each ASL module can be separately written without the knowledge of other modules and so each module can interact with other modules via an event mechanism.

Accordingly, it would be desirable to provide an improved modular ASL absent the disadvantages discussed above.

SUMMARY

According to one embodiment, a system for source language module interaction uses an event mechanism and includes one or more subsystems to detect a producer event, detect a consumer event, generate a new source language method for the producer event and a new source language method for the consumer event, and link the producer event and the consumer event using the new source language method.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an embodiment of an information handling system (IHS).

FIGS. 2A and 2B illustrate a flowchart of an embodiment of a method to link a consumer and a producer in a modular ACPI source language component.

FIG. 3 illustrates an embodiment of a source code before being converted by a script code in accordance with an embodiment of the present disclosure.

FIG. 4 illustrates an embodiment of the source code of FIG. 3 after being converted by a script code in accordance with an embodiment of the present disclosure.

DETAILED DESCRIPTION

For purposes of this disclosure, an IHS 100 includes any instrumentality or aggregate of instrumentalities operable to compute, classify, process, transmit, receive, retrieve, originate, switch, store, display, manifest, detect, record, reproduce, handle, or utilize any form of information, intelligence, or data for business, scientific, control, or other purposes. For example, an IHS 100 may be a personal computer, a network storage device, or any other suitable device and may vary in size, shape, performance, functionality, and price. The IHS 100 may include random access memory (RAM), one or more processing resources such as a central processing unit (CPU) or hardware or software control logic, read only memory (ROM), and/or other types of nonvolatile memory. Additional components of the IHS 100 may include one or more disk drives, one or more network ports for communicating with external devices as well as various input and output (I/O) devices, such as a keyboard, a mouse, and a video display. The IHS 100 may also include one or more buses operable to transmit communications between the various hardware components.

FIG. 1 is a block diagram of one IHS 100. The IHS 100 includes a processor 102 such as an Intel Pentium™ series processor or any other processor available. A memory I/O hub chipset 104 (comprising one or more integrated circuits) connects to processor 102 over a front-side bus 106. Memory I/O hub 104 provides the processor 102 with access to a variety of resources. Main memory 108 connects to memory I/O hub 104 over a memory or data bus. A graphics processor 110 also connects to memory I/O hub 104, allowing the graphics processor to communicate, e.g., with processor 102 and main memory 108. Graphics processor 110, in turn, provides display signals to a display device 112.

Other resources can also be coupled to the system through the memory I/O hub 104 using a data bus, including an optical drive 114 or other removable-media drive, one or more hard disk drives 116, one or more network interfaces 118, one or more Universal Serial Bus (USB) ports 120, and a super I/O controller 122 to provide access to user input devices 124, etc. The IHS 100 may also include a solid state drive (SSDs) 126 in place of, or in addition to main memory 108, the optical drive 114, and/or a hard disk drive 116. It is understood that any or all of the drive devices 114, 116, and 126 may be located locally with the IHS 100, located remotely from the IHS 100, and/or they may be virtual with respect to the IHS 100.

Not all IHSs 100 include each of the components shown in FIG. 1, and other components not shown may exist. Furthermore, some components shown as separate may exist in an integrated package or be integrated in a common integrated circuit with other components, for example, the processor 102 and the memory I/O hub 104 can be combined together. As can be appreciated, many systems are expandable, and include or can include a variety of components, including redundant or parallel resources.

The present disclosure solves the problem of needing to build the modular concept (similar to UEFI) so that each ASL code module may be separately written without the knowledge of other modules and so each module can interact with other modules via an event mechanism. In an embodiment, the problem is solved by adding an ASL Signal/Create event concept to ASL language.

In an embodiment, a UEFI BIOS will be used to auto generate a new ASL method for each event and link both the producer and consumer event using this new ASL method. As such, the BIOS build process may accomplish this using special tags, such as, <CreateEvent(..)>, <SignalEvent(..) in the ASL Modules. The BIOS build process may also accomplish this using a globally unique identifier (GUILD) to uniquely define an event name. A GUID is generally known as a special type of identifier used in software applications to provide a reference number that is unique in any context. Also, the BIOS build process may accomplish this using a special preprocessor utility (e.g., Perl script) that will parse the ASL modules at build time and link all those consumer/producer events by generating new ACPI methods and filling it appropriately. Furthermore, the BIOS build process may accomplish this using a final ASL compilation to build an ACPI binary (called the AML code).

Each ASL modules may be isolated and will not refer to other ASL module directly, but instead through event mechanism. An ASL module will broadcast the event by signaling an event with a unique GUID and other ASL module will receive that events by creating an event with the same GUID and defining the ASL method associated with the method.

Use of a GUID as event name offers a concept as a unique number is generated each time a GUID is generated by GUID tools. Thus, a BIOS developer may create a unique Event name without worrying about the event name colliding with some other event name.

The ASL module that produces/broadcasts the event may use a special tag, such as, “<SingalEvent(Event_GUID>” in the ASL code. The ASL modules that consume the event will use a special tag, such as, “<CreateEvent(Event_GUID, ASLMethodb>” in the ASL code where the ASLMethodb is the actual ASL method that needs to be executed.

During the BIOS build time, a special preprocessor utility (e.g., a perl script) will parse the special tags, such as, <SingalEvent(..)> and <CreateEvent(..)> and create a hash table for each GUID. A hash table is generally referred to by a person having ordinary skill in the art as a data structure that associates keys with values. As such, a hash table supports efficient lookup of information. The contents of hash table include the ASL method names of producers and consumer of the event. After parsing the ASL modules, the preprocessor utility may create a unique method for each unique event GUID it can find. Also, after parsing the ASL modules, the preprocessor utility may replace the ASL line with special tag, such as, “<SignalEvent (Event_GUID,XYZ)>” with the new method that it created. The preprocessor may auto create this new method. This new method may include all the ASL methods that are consumed by this event.

FIGS. 2A and 2B illustrate a flowchart of an embodiment of a method 130 to link a consumer and a producer in a modular ACPI source language component. The method 130 starts at 132. The method 130 then proceeds to block 134 where the method 130 reads an ASL file into a local buffer. The method 130 then proceeds to block 136 where the method 130 reads the next line in the buffer. The method 130 then proceeds to decision block 138 where the method 130 determines whether a tag (e.g., <CreateEvent(xx,yy)>) is found where xx is a GUID and yy is a method name. If the answer is no in decision block 138, the method 130 proceeds to decision block 146 as described in more detail below. If the answer is yes in decision block 138, the method 130 proceeds to decision block 140 where the method 130 determines whether a unique event method name exists for this GUID in the hash table. If the answer is yes in decision block 140, the method 130 proceeds to block 144 as described in more detail below. If the answer is no in decision block 140, the method 130 proceeds to block 142 where the method 130 generates a unique name (e.g., unique_name=GenerateUniqueName( ); HASH1 {XX}=unique_name). The method 130 then proceeds to block 144 where the method 130 adds a name to the array (e.g., AddArray (xx,yy) add name yy to the array associated with the GUID (xx). The method 130 then proceeds to decision block 146 where the method 130 determines whether a tag (e.g., <SignalEvent(xx)>) is found where xx is a GUID and yy is a method name. If the answer is no in decision block 146, the method 130 proceeds to decision block 154 as described in more detail below. If the answer is yes in decision block 146, the method 130 proceeds to decision block 148 where the method 130 determines whether a unique event method name exists for this GUID in the hash table. If the answer is yes in decision block 148, the method 130 proceeds to block 152 as described in more detail below. If the answer is no in decision block 148, the method 130 proceeds to block 150 where the method 130 generates a unique name (e.g., unique_name=GenerateUniqueName( ); HASH1 {XX}=unique_name). The method 130 then proceeds to block 152 where the method 130 replaces a name in the array (e.g., Replace the Current line with a newstring “<Unique_name>( )”. The method 130 then proceeds to decision block 154 where the method determines whether the end of the file has been reached. If the answer is no in decision block 154, the method 130 returns to block 136. If the answer is yes in decision block 154, the method 130 proceeds to block 156 where the method 130 reads the hash table element for each GUID xx, one at a time, (Unique_name=Hash (xx). In block 156, the method 130 also adds a new line in the ASL file with string “Method (<Unique_Name>( ){”. The method 130 then proceeds to block 158 where the method 130 parses the array associated with Array (xx) and for each <Method_name> in the array xx. In block 158, the method 130 also adds a new line with string “<Method_name>( )”. The method 130 then proceeds to block 160 where the method 130 adds a line with string “}” to complete the method with name Unique_name. The method 130 then proceeds to decision block 162 where the method 130 determines whether a next element exists in the hash table. If the answer is yes in decision block 162, the method 130 returns to block 156. If the answer is no in decision block 162, the method proceeds to 164 where the method 130 completes the ASL code and ends.

FIG. 3 illustrates an embodiment of a source code before being converted by a script code in accordance with an embodiment of the present disclosure. FIG. 4 illustrates an embodiment of the source code of FIG. 3 after being converted by a script code in accordance with an embodiment of the present disclosure.

In an embodiment, the script program will convert the code of FIG. 3 into the code of FIG. 4. As one should notice, the script code auto created method El1( ) that is called from _PTS method. A perl script also defined the method El1( ) and in this method it calls both consumer methods (PrepareKbdWake & PrepareLOMWake). It should be readily understood by one having ordinary skill in the art that other source codes may be used with the present disclosure.

Although illustrative embodiments have been shown and described, a wide range of modification, change and substitution is contemplated in the foregoing disclosure and in some instances, some features of the embodiments may be employed without a corresponding use of other features. Accordingly, it is appropriate that the appended claims be construed broadly and in a manner consistent with the scope of the embodiments disclosed herein. 

1. A system for source language module interaction using an event mechanism, the system comprising one or more subsystems to: detect a producer event; detect a consumer event; generate a new source language method for the producer event and a new source language method for the consumer event; and link the producer event and the consumer event using the new source language method.
 2. The system of claim 1, wherein the source language is advanced configuration and power interface (ACPI) source language (ASL).
 3. The system of claim 1, further comprising one or more subsystems to: use a globally unique identifier (GUID) to uniquely define an event name.
 4. The system of claim 3, wherein the GUID is stored in a hash table.
 5. The system of claim 3, further comprising one or more subsystems to: use a preprocessor to create a unique method for a unique event GUID.
 6. The system of claim 5, further comprising one or more subsystems to: use the preprocessor to replace a source language line with a special using the method for a unique event GUID.
 7. The system of claim 6, wherein the preprocessor auto creates the unique method.
 8. An information handling system (IHS) comprising: a processor; memory to store a plurality of source language methods to be processed by the processor; and a system for source language module interaction using an event mechanism, the system for source language module interaction further comprising one or more subsystems to: detect a producer event; detect a consumer event; generate a new source language method for the producer event and a new source language method for the consumer event; and link the producer event and the consumer event using the new source language method.
 9. The IHS of claim 8, wherein the source language is advanced configuration and power interface (ACPI) source language (ASL).
 10. The IHS of claim 8, further comprising one or more subsystems to: use a globally unique identifier (GUID) to uniquely define an event name.
 11. The IHS of claim 10, wherein the GUID is stored in a hash table.
 12. The IHS of claim 10, further comprising one or more subsystems to: use a preprocessor to create a unique method for a unique event GUID.
 13. The IHS of claim 12, further comprising one or more subsystems to: use the preprocessor to replace a source language line with a special using the method for a unique event GUID.
 14. The IHS of claim 13, wherein the preprocessor auto creates the unique method.
 15. A method for source language module interaction using an event mechanism, the method comprising: detecting a producer event; detecting a consumer event; generating a new source language method for the producer event and a new source language method for the consumer event; and linking the producer event and the consumer event using the new source language method.
 16. The method of claim 15, wherein the source language is advanced configuration and power interface (ACPI) source language (ASL).
 17. The method of claim 15, further comprising: using a globally unique identifier (GUID) to uniquely define an event name.
 18. The method of claim 17, wherein the GUID is stored in a hash table.
 19. The method of claim 17, further comprising: using a preprocessor to create a unique method for a unique event GUID.
 20. The method of claim 19, further comprising: using the preprocessor to replace a source language line with a special using the method for a unique event GUID. 